#include "Tool.h"



GenQue gl_GenQue;

QueNode ps[5];
int pdata[5] = {0x11,0x22,0x33,0x44,0x55};

STACK_ARRAY_T StackArr;


/*-----------------------------链表操作相关---------------------------------*/
/**
\Function:  Linklist_Node_Init
\brief:  初始化链表
\In：HeadNode - 链表头结点
\Out：true:false
\auth:Zhaofujia
**/
void Linklist_Node_Init(NODE_TYPE* Node)
{
	Node->higher = NULL;
	Node->next = NULL;
	Node->lower = NULL;
}
/**
\Function:  SingleLinklist_Tail_Insert
\brief:  单链表插入节点，单次尾插法
\In：HeadNode - 链表头结点
      NodeToInsert - 待插入的节点
\Out：true:false
\auth:Zhaofujia
**/
bool LinklistSingle_Tail_Insert(NODE_TYPE * HeadNode,NODE_TYPE * NodeToInsert)
{
	 NODE_TYPE * TmpNode = HeadNode;
	 
	 while(TmpNode->next != NULL)  //获取尾节点
	 {
		  TmpNode = TmpNode->next;
	 }
	 
	 NodeToInsert->next = NULL;
	 TmpNode->next = NodeToInsert;
	 
	 return true;
}

/**
\Function:  LinklistSingle_Head_Insert
\brief:  单链表插入节点，单次头插法
\In: HeadNode - 链表头结点
      NodeToInsert - 待插入的节点
\Out：true:false
\auth:Zhaofujia
**/
bool LinklistSingle_Head_Insert(NODE_TYPE * HeadNode,NODE_TYPE * NodeToInsert)
{
	 NODE_TYPE * TmpNode = HeadNode;
	 
	 NodeToInsert->next = TmpNode->next;
	 TmpNode->next = NodeToInsert;
	
	 return true;
}


/**
\Function:  LinklistSingle_Head_PopGet
\brief:  从单链表头部获取对象,并从队列里删除
\In: HeadNode - 链表头结点
\Out：node
\date: 20190108 jia
**/
NODE_TYPE * LinklistSingle_Head_PopGet(NODE_TYPE * HeadNode)
{
	 NODE_TYPE * TmpNode = HeadNode->next;
	
	 if(NULL == TmpNode)
	 {  return NULL; }
	 
	 HeadNode->next = TmpNode->next;
	 TmpNode->next = NULL;
	 
	 return TmpNode;
}

/**
\Function:  LinklistSingle_Del_Node
\brief:  从队列里删除制定的结点
\In: HeadNode - 链表头结点
		DelNode -  待删除结点
\Out: true:false
\date: 20190108 jia
**/
bool LinklistSingle_Del_Node(NODE_TYPE * HeadNode,NODE_TYPE * DelNode)
{
	NODE_TYPE * LastNode;
  NODE_TYPE * TmpNode;
	
	TmpNode = HeadNode->next;
	LastNode = HeadNode;
	
	if(TmpNode == NULL)  //链表队列为空
	{  return false; }
	
	while(TmpNode != NULL)  //当前结点不为空
	{
		 if(TmpNode == DelNode)
		 {  
		   LastNode->next = TmpNode->next;
			 TmpNode->next = NULL;  //清空指针信息
			 return true;
		 }
		 
		 TmpNode = TmpNode->next;
		 LastNode = LastNode->next;
	}
	
	return false;
}

/**
\Function:   LinklistSingle_Clear
\brief:  清空单链表
\In: HeadNode - 链表头结点
\Out: nil
**/
void LinklistSingle_Clear(NODE_TYPE * HeadNode)
{
	NODE_TYPE * p;
	NODE_TYPE * TmpNode = HeadNode;
	
	p = TmpNode->next;
	
	while(p)   //逐个断开链表 清空数据
	{
		TmpNode = p;
		p = p->next;
		TmpNode->next = NULL;
	}
	
	HeadNode->next = NULL;
}

/*-----------------------链表队列操作相关-----非动态分配----------------------*/
/**
函数名称:  GenQueue_Init
函数功能:  初始化链表队列
输入：pq - 队列头指针
输出：true:false
\auth:Zhaofujia
*/
bool GenQueue_Init(PGenQue pq)
{
	if(pq == NULL)
	{  return false; }
	pq->count = 0;
	pq->phead = NULL;
  return true;
}

/**
函数名称:  GenQueue_IsEmpty
函数功能:  判断队列是否为空
输入：pq - 队列头指针
输出：true:false
\auth:Zhaofujia
*/
bool GenQueue_IsEmpty(PGenQue pq)
{
   return (pq->phead == NULL);
}

/**
函数名称:  GenQueue_GetLength
函数功能:  获取队列中元素个数
输入：pq - 队列头指针
输出：元素个数
\auth:Zhaofujia
*/
int GenQueue_GetLength(PGenQue pq)
{
	 return pq->count;
}

/**
函数名称:  GenQueue_Insert
函数功能:  向队列中插入元素
输入：pq - 队列头指针，pnode - 待加入队列的元素
输出：true:false
\date: 20190212 jia
*/
bool GenQueue_Insert(PGenQue pq,PQuekNode pnode) 
{
	QueNode* TmpNode;
	
	if((pq == NULL) || (pnode == NULL))
	{  return false; }
	
	if(!GenQueue_IsEmpty(pq))
	{
		 TmpNode = pq->phead;
		
		 while(TmpNode->next != NULL)
		 {
			 TmpNode = TmpNode->next;
		 }
			
		 pnode->next = NULL;
		 TmpNode->next = pnode;
	}
	else
	{
		 pnode->next = NULL;
		 pq->phead = pnode;
	}
	
	pq->count++;
	
  return true;
}

/**
函数名称:  GenQueue_Get
函数功能:  向队列中插入元素
输入：pq - 队列头指针，*pnode - 待获取的元素
输出：true:false
\auth:Zhaofujia
*/
bool GenQueue_Get(PGenQue pq,PQuekNode* pnode) 
{
	if(pq == NULL)
	{  return false; }
	if(GenQueue_IsEmpty(pq))
	{  return false; }
	
	(*pnode) = pq->phead;
	pq->phead = (*pnode)->next;
	(*pnode)->next = NULL;
	
	pq->count--;
	
  return true;
}

bool GenQueue_IsExist(PGenQue pq,PQuekNode pnode)
{
	QueNode* TmpNode;
	
	if((pq == NULL) || (pnode == NULL))
	{  return false; }
	if(GenQueue_IsEmpty(pq))
	{  return false; }
	
	TmpNode = pq->phead;
	if(TmpNode->data == pnode->data)
	{  return true; }
	
	while(TmpNode->next != NULL)
	{
		TmpNode = TmpNode->next;
		if(TmpNode->data == pnode->data)
	  {  return true; }
	}
	
	return false;
}
/*
函数名称:  GenQueue_Clear
函数功能:  清空队列
输入：pq - 队列头指针
输出：true:false
*/
bool GenQueue_Clear(PGenQue pq)
{
	QueNode* TmpNode = NULL;
	
	if(pq == NULL)
	{ 
	  return false; 
	}
	
	if(GenQueue_IsEmpty(pq))
	{  
		pq->count = 0;
	  return true; 
	}
	
	while(pq->phead != NULL)
	{
		 TmpNode = pq->phead;
		 pq->phead = TmpNode->next;
		 TmpNode->next = NULL;
		 TmpNode->data = NULL;
	}
	
	pq->count = 0;
  return true;
	
}



//bool GenQueue_Insert(PGenQue pq,PQuekNode pnode)  //类似单链表头插法
//{
//	if((pq == NULL) || (pnode == NULL))
//	{  return false; }
//	 
//	pnode->next = pq->phead;
//	pq->phead = pnode;
//	pq->count++;
//  return true;
//}

//bool GenQueue_Get(PGenQue pq,PQuekNode* pnode) 
//{
//	static QueNode * Node;
//	static QueNode * PenultNode;
//	
//	if(pq == NULL)
//	{  return false; }
//	if(GenQueue_IsEmpty(pq))
//	{  return false; }
//	
//	Node = pq->phead->next;
//	PenultNode = Node;
//	
//	while(Node->next != NULL)
//	{
//		PenultNode = Node;
//		Node = Node->next;
//	}
//	
//	(*pnode) = Node;
//	PenultNode->next = NULL;
//	
//	pq->count--;
//	
//  return true;
//	
//}


/*-----------------------链表栈操作相关-----非动态分配-----------------------*/
/*
函数名称:  GenStack_Init
函数功能:  初始化栈
输入：ps - 栈指针
输出：true:false
date:20190108 jia
*/
bool GenStack_Init(PGenStack ps)
{
	if(ps == NULL)
	{  return false; }
	ps->count = 0;
	ps->phead = NULL;
  return true;
}

/*
函数名称:  GenStack_IsEmpty
函数功能:  判断栈是否为空
输入：ps - 栈指针
输出：true:false
date:20190108 jia
*/
bool GenStack_IsEmpty(PGenStack ps)
{
   return (ps->phead == NULL);
}

/*
函数名称:  GenStack_GetLength
函数功能:  获取栈内容数量
输入：ps - 栈指针
输出：true:false
date:20190108 jia
*/
int GenStack_GetLength(PGenStack ps)
{
	 return ps->count;
}

/*
函数名称:  GenStack_Push
函数功能:  压栈
输入：ps - 栈指针
      pnode - 栈内容节点指针
输出：true:false
date:20190108 jia
*/
bool GenStack_Push(PGenStack ps,PStkNode pnode)
{
	if((ps == NULL) || (pnode == NULL))
	{  return false; }
	
  pnode->next = ps->phead;
  ps->phead = pnode;
  ps->count++;
  return true;
}

/*
函数名称:  GenStack_GetTop
函数功能:  获取栈顶元素， 但不删除
输入：ps - 栈指针
      pnode - 赋值内容节点指针
输出：true:false
date:20190108 jia
*/
bool GenStack_GetTop(PGenStack ps,PStkNode pnode)
{
	if((ps == NULL) || (pnode == NULL))
	{  return false; }
	if(GenStack_IsEmpty(ps))
	{ return false; }

	pnode = ps->phead;
	
  return true;
}

/*
函数名称:  GenStack_Pop
函数功能:  获取栈顶元素，并删除
输入：ps - 栈指针
      pnode - 赋值内容节点指针
输出：true:false
date:20190108 jia
*/
bool GenStack_Pop(PGenStack ps,PStkNode* pnode)
{
	if(ps == NULL)
	{  return false; }
	if(GenStack_IsEmpty(ps))
	{ return false; }
	
  *pnode = ps->phead;
	ps->phead = (*pnode)->next;
	(*pnode)->next = NULL;
	
  ps->count--;
  return true;
}

/*
函数名称:  GenStack_Distory
函数功能:  销毁栈，并清空栈内元素
输入：ps - 栈指针
输出：true:false
date:20190108 jia
*/
bool GenStack_Distory(PGenStack ps)
{
	PStkNode pnode = NULL;
	
	if(ps == NULL)
	{  return false; }
	if(GenStack_IsEmpty(ps))
	{  return false; }
	
	while(ps->phead != NULL)
	{
		pnode = ps->phead;
		ps->phead = pnode->next;
		pnode->next = NULL;
		pnode->data = NULL;
	}

  ps->count = 0;
  return true;
}


/*-----------------------数组栈操作相关-----非动态分配-----------------------*/
/*
函数名称:  StackArr_Init
函数功能:  初始化栈
输入：ps - 栈指针
输出：true:false
*/
bool StackArr_Init(void)
{
	memset(&StackArr,0,sizeof(STACK_ARRAY_T));
	StackArr.Tail = -1;
  return true;
}

/*
函数名称:  Stack_Is_Empty
函数功能:  栈是否为空
输入：nil
输出：true: 栈为空 false：栈不为空
*/
static bool Stack_Is_Empty(void)
{
	return (StackArr.Tail == -1) ? true:false;
}

/*
函数名称:  Stack_Is_Full
函数功能:  栈是否为满
输入：nil
输出：true: 栈满 false：栈没有满
*/
static bool Stack_Is_Full(void)
{
	return (StackArr.Tail == (STACK_ARR_NUM-1)) ? true:false;
}

/*
函数名称:  StackArr_Push
函数功能:  压栈
输入：ps - 栈指针
输出：true: 压栈成功  false: 满了不能压栈
*/
bool StackArr_Push(void * data)
{
	short i = 0;
	
	if(Stack_Is_Full()) //栈已满
	{ return false; }
	
	for(i = (StackArr.Tail+1); i > 0; i--)
	{
		StackArr.Stack[i] = StackArr.Stack[i-1];
	}
	StackArr.Stack[0] = data;
	StackArr.Tail++;
  return true;
}

/*
函数名称:  StackArr_Pop
函数功能:  出栈
输入：nil
输出：不为空: 出栈成功  Null: 栈内为空
*/
void * StackArr_Pop(void)
{
	void * data = NULL;
	short i = 0;
	
	if(Stack_Is_Empty()) //栈为空
	{	return NULL;}
	
	data = StackArr.Stack[0];
	for(i = 1; i <= StackArr.Tail; i++)
	{
		StackArr.Stack[i-1] = StackArr.Stack[i];
	}
	
	StackArr.Stack[StackArr.Tail] = NULL;
	--StackArr.Tail;
	
  return data;
}

/*
函数名称:  StackArr_GetTop
函数功能:  获取栈顶元素(不出栈)
输入：nil
输出：不为空: 出栈成功  Null: 栈内为空
*/
void * StackArr_GetTop(void)
{
	if(Stack_Is_Empty()) //Idx为-1 则栈为空
	{	return NULL;}
	
	return StackArr.Stack[0];
}


////--------------------test ---------part---------------------

//void Test_GenQueue(void)
//{
//	
//	QueNode* reqNode;

//	unsigned char i = 0;
//	
//	GenQueue_Init(&gl_GenQue);
//	
//	for(i = 0; i < 5; i++)
//	{
//		ps[i].data = &pdata[i];
//		ps[i].next = NULL;
//	}
//	
//	for(i = 0; i < 5; i++)
//	{
//		GenQueue_Insert(&gl_GenQue,&ps[i]);
//	}
//	
////	for(i = 0; i < 5; i++)
////	{
////		GenQueue_Get(&gl_GenQue,reqNode);
////	}
//	
//	GenQueue_Clear(&gl_GenQue);
//	
//}













































